package com.domor.xxx.framework.jwt.utils;

import com.domor.xxx.common.exception.TokenException;
import com.domor.xxx.common.utils.security.Base64Util;
import io.jsonwebtoken.*;
import lombok.extern.slf4j.Slf4j;

import javax.crypto.spec.SecretKeySpec;
import javax.xml.bind.DatatypeConverter;
import java.security.Key;
import java.util.Date;

/**
* @Desc: jwt token 工具类
* @Author: liyuyang
* @Date: 2020/3/31
**/
@Slf4j
public class JwtTokenUtil {

    public static final String AUTH_HEADER_KEY = "Authorization";

    public static final String TOKEN_PREFIX = "Bearer ";

    /* 密钥, 经过Base64加密, 可自行替换 */
    public static final String CLIENT_ID = "098f6bcd4621d373cade4e832627b4f6";

    /* 密钥, 经过Base64加密, 可自行替换 */
    public static final String BASE64_SECRET = "MDk4ZjZiY2Q0NjIxZDM3M2NhZGU0ZTgzMjYyN2I0ZjY=";

    /* JWT的签发主体，存入issuer */
    public static final String JWT_NAME = "appUser";

    /* 过期时间，时间戳 */
    public static final long EXPIRES_SECOND = 365 * 24 * 60 * 60 * 1000;

    /**
     * 解析jwt
     * @param jsonWebToken
     * @return
     */
    public static Claims parseJWT(String jsonWebToken) {
        try {
            Claims claims = Jwts.parser()
                    .setSigningKey(DatatypeConverter.parseBase64Binary(BASE64_SECRET))
                    .parseClaimsJws(jsonWebToken).getBody();
            return claims;
        } catch (ExpiredJwtException  eje) {
            log.error("===== Token过期 =====", eje);
            throw new TokenException("token timeout");
        } catch (Exception e){
            log.error("===== token解析异常 =====", e);
            throw new TokenException("token invalid");
        }
    }

    /**
     * 构建jwt
     * @param username
     * @param roleKey
     * @return
     */
    public static String createJWT(String username, String roleKey, int deptId) {
        try {
            // 使用HS256加密算法
            SignatureAlgorithm signatureAlgorithm = SignatureAlgorithm.HS256;

            long nowMillis = System.currentTimeMillis();
            Date now = new Date(nowMillis);

            //生成签名密钥
            byte[] apiKeySecretBytes = DatatypeConverter.parseBase64Binary(BASE64_SECRET);
            Key signingKey = new SecretKeySpec(apiKeySecretBytes, signatureAlgorithm.getJcaName());

            //userId是重要信息，进行加密下
            String encryId = Base64Util.encode(username);

            //添加构成JWT的参数
            JwtBuilder builder = Jwts.builder().setHeaderParam("typ", "JWT")
                    // 可以将基本不重要的对象信息放到claims
                    .claim("roleKey", roleKey)
                    .claim("deptId", deptId)
                    .setSubject(username)           // 代表这个JWT的主体，即它的所有人
                    .setIssuer(CLIENT_ID)           // 代表这个JWT的签发主体；
                    .setIssuedAt(new Date())        // 是一个时间戳，代表这个JWT的签发时间；
                    .setAudience(JWT_NAME)          // 代表这个JWT的接收对象；
                    .signWith(signatureAlgorithm, signingKey);

            //添加Token过期时间
            long TTLMillis = EXPIRES_SECOND;
            if (TTLMillis >= 0) {
                long expMillis = nowMillis + TTLMillis;
                Date exp = new Date(expMillis);
                builder.setExpiration(exp)  // 是一个时间戳，代表这个JWT的过期时间；
                        .setNotBefore(now); // 是一个时间戳，代表这个JWT生效的开始时间，意味着在这个时间之前验证JWT是会失败的
            }

            //生成JWT
            return builder.compact();
        } catch (Exception e) {
            log.error("签名失败", e);
            throw new TokenException("ResultCode.PERMISSION_SIGNATURE_ERROR");
        }
    }

    /**
     * 从token中获取用户名
     * @param token
     * @return
     */
    public static String getUsername(String token){
        return parseJWT(token).getSubject();
    }

    /**
     * 从token中获取roleKey
     * @param token
     * @return
     */
    public static String getRoleKey(String token){
        return parseJWT(token).get("roleKey", String.class);
    }

    /**
     * 从token中获取deptId
     * @param token
     * @return
     */
    public static Integer getDeptId(String token){
        return parseJWT(token).get("deptId", Integer.class);
    }

    /**
     * 从token中获取用户ID
     * @param token
     * @return
     */
    public static String getUserId(String token){
        String userId = parseJWT(token).get("userId", String.class);
        return Base64Util.decode(userId);
    }

    /**
     * 是否已过期
     * @param token
     * @return
     */
    public static boolean isExpiration(String token) {
        return parseJWT(token).getExpiration().before(new Date());
    }

}
